package com.jim.director.framework.validation;

import com.jim.director.framework.tool.PackageScanner;

import java.util.ArrayList;
import java.util.List;

/**
 * 注解校验引擎
 * 整合所有校验器，提供统一的校验接口
 *
 * @author Jim
 * @date 2024/10/5
 */
public class AnnotationValidationEngine {

    private List<AnnotationValidator> validators;

    public AnnotationValidationEngine() {
        this.validators = new ArrayList<>();
        initializeValidators();
    }

    /**
     * 初始化所有校验器
     */
    private void initializeValidators() {
        validators.add(new ActorValidator());
        validators.add(new ActionValidator());
        validators.add(new DependencyValidator());
        validators.add(new SystemAnnotationValidator());
    }

    /**
     * 校验指定启动类包下的所有类
     * @param starter 启动类
     * @return 校验报告
     */
    public ValidationReport validateAll(Class<?> starter) {
        ValidationReport report = new ValidationReport();

        try {
            // 扫描所有类
            List<Class<?>> classes = PackageScanner.scanPackage(starter);

            System.out.println("开始注解校验...");
            System.out.println("扫描到 " + classes.size() + " 个类");

            // 对每个类进行校验
            for (Class<?> clazz : classes) {
                ValidationResult classResult = validateClass(clazz);
                if (classResult.hasErrors() || classResult.hasWarnings()) {
                    report.addResult(classResult);
                }
            }

            System.out.println("注解校验完成");

        } catch (Exception e) {
            ValidationResult errorResult = new ValidationResult("校验引擎");
            errorResult.addError("注解校验过程中发生异常: " + e.getMessage());
            report.addResult(errorResult);
            e.printStackTrace();
        }

        return report;
    }

    /**
     * 校验单个类
     * @param clazz 要校验的类
     * @return 该类的校验结果
     */
    public ValidationResult validateClass(Class<?> clazz) {
        ValidationResult result = new ValidationResult(clazz.getSimpleName());

        // 使用所有校验器校验该类
        for (AnnotationValidator validator : validators) {
            try {
                ValidationResult validatorResult = validator.validate(clazz);
                result.merge(validatorResult);
            } catch (Exception e) {
                result.addError(String.format(
                    "校验器 %s 在校验类 %s 时发生异常: %s",
                    validator.getValidatorName(), clazz.getSimpleName(), e.getMessage()
                ));
            }
        }

        return result;
    }

    /**
     * 添加自定义校验器
     * @param validator 自定义校验器
     */
    public void addValidator(AnnotationValidator validator) {
        this.validators.add(validator);
    }

    /**
     * 移除校验器
     * @param validatorClass 要移除的校验器类型
     */
    public void removeValidator(Class<? extends AnnotationValidator> validatorClass) {
        validators.removeIf(validator -> validator.getClass().equals(validatorClass));
    }

    /**
     * 获取所有校验器
     * @return 校验器列表
     */
    public List<AnnotationValidator> getValidators() {
        return new ArrayList<>(validators);
    }

    /**
     * 按名称获取校验器
     * @param validatorName 校验器名称
     * @return 校验器实例，如果不存在则返回null
     */
    public AnnotationValidator getValidator(String validatorName) {
        return validators.stream()
                .filter(validator -> validator.getValidatorName().equals(validatorName))
                .findFirst()
                .orElse(null);
    }

    /**
     * 校验指定类列表
     * @param classes 要校验的类列表
     * @return 校验报告
     */
    public ValidationReport validateClasses(List<Class<?>> classes) {
        ValidationReport report = new ValidationReport();

        System.out.println("开始校验 " + classes.size() + " 个指定类...");

        for (Class<?> clazz : classes) {
            try {
                ValidationResult classResult = validateClass(clazz);
                if (classResult.hasErrors() || classResult.hasWarnings()) {
                    report.addResult(classResult);
                }
            } catch (Exception e) {
                ValidationResult errorResult = new ValidationResult(clazz.getSimpleName());
                errorResult.addError("校验类 " + clazz.getSimpleName() + " 时发生异常: " + e.getMessage());
                report.addResult(errorResult);
            }
        }

        System.out.println("指定类校验完成");
        return report;
    }

    /**
     * 检查是否启用了详细模式（用于调试）
     */
    public void setVerboseMode(boolean verbose) {
        // 可以在这里添加详细模式的控制逻辑
        if (verbose) {
            System.out.println("启用详细校验模式");
            System.out.println("已注册的校验器: ");
            for (AnnotationValidator validator : validators) {
                System.out.println("- " + validator.getValidatorName());
            }
        }
    }
}

